{
/* Just some sanity to ensure that the scheduler is set up okay. */
ASSERT(current->domain == IDLE_DOMAIN_ID);
- domain_unpause_by_systemcontroller(current);
- __enter_scheduler();
+ domain_unpause_by_systemcontroller(current);
+ raise_softirq(SCHEDULE_SOFTIRQ);
+ do_softirq();
/*
* Declares CPU setup done to the boot processor.
/* Just some sanity to ensure that the scheduler is set up okay. */
ASSERT(current->domain->id == IDLE_DOMAIN_ID);
domain_unpause_by_systemcontroller(current->domain);
- __enter_scheduler();
+ raise_softirq(SCHEDULE_SOFTIRQ);
+ do_softirq();
/*
* Declares CPU setup done to the boot processor.
if ( unlikely(shadow_mode_enabled(d)) )
check_pagetable(d, ed->arch.guest_table, "pre-mmu"); /* debug */
- if ( unlikely(shadow_mode_translate(d) ) )
- domain_crash();
+ if ( unlikely(shadow_mode_translate(d)) )
+ domain_crash_synchronous();
/*
* If we are resuming after preemption, read how much work we have already
if ( unlikely(!__addr_ok(va)) )
return -EINVAL;
- if ( unlikely(shadow_mode_translate(d) ) )
- domain_crash();
+ if ( unlikely(shadow_mode_translate(d)) )
+ domain_crash_synchronous();
LOCK_BIGLOCK(d);
MEM_LOG("ptwr: Could not read pte at %p\n", ptep);
/*
* Really a bug. We could read this PTE during the initial fault,
- * and pagetables can't have changed meantime. XXX Multi-CPU guests?
+ * and pagetables can't have changed meantime.
*/
BUG();
}
MEM_LOG("ptwr: Could not update pte at %p\n", ptep);
/*
* Really a bug. We could write this PTE during the initial fault,
- * and pagetables can't have changed meantime. XXX Multi-CPU guests?
+ * and pagetables can't have changed meantime.
*/
BUG();
}
unmap_domain_mem(pl1e);
ptwr_info[cpu].ptinfo[which].l1va = 0;
domain_crash();
+ return;
}
if ( unlikely(sl1e != NULL) )
unmap_domain_mem(ptwr_info[cpu].ptinfo[which].pl1e);
ptwr_info[cpu].ptinfo[which].l1va = 0;
domain_crash();
+ return 0;
}
return EXCRET_fault_fixed;
#ifndef NDEBUG
-void ptwr_status(void)
-{
- unsigned long pte, *ptep, pfn;
- struct pfn_info *page;
- int cpu = smp_processor_id();
-
- ptep = (unsigned long *)&linear_pg_table
- [ptwr_info[cpu].ptinfo[PTWR_PT_INACTIVE].l1va>>PAGE_SHIFT];
-
- if ( __get_user(pte, ptep) ) {
- MEM_LOG("ptwr: Could not read pte at %p\n", ptep);
- domain_crash();
- }
-
- pfn = pte >> PAGE_SHIFT;
- page = &frame_table[pfn];
- printk("need to alloc l1 page %p\n", page);
- /* make pt page writable */
- printk("need to make read-only l1-page at %p is %p\n",
- ptep, pte);
-
- if ( ptwr_info[cpu].ptinfo[PTWR_PT_ACTIVE].l1va == 0 )
- return;
-
- if ( __get_user(pte, (unsigned long *)
- ptwr_info[cpu].ptinfo[PTWR_PT_ACTIVE].l1va) ) {
- MEM_LOG("ptwr: Could not read pte at %p\n", (unsigned long *)
- ptwr_info[cpu].ptinfo[PTWR_PT_ACTIVE].l1va);
- domain_crash();
- }
- pfn = pte >> PAGE_SHIFT;
- page = &frame_table[pfn];
-}
-
void audit_pagelist(struct domain *d)
{
struct list_head *list_ent;
&linear_pg_table[va >> PAGE_SHIFT])) )
{
SH_VVLOG("shadow_fault - EXIT: read gpte faulted2" );
- shadow_unlock(d);
- return 0;
+ goto fail;
}
if ( unlikely(!(gpte & _PAGE_PRESENT)) )
{
SH_VVLOG("shadow_fault - EXIT: gpte not present2 (%lx)",gpte );
- shadow_unlock(d);
- return 0;
+ goto fail;
}
/* Write fault? */
{
/* Write fault on a read-only mapping. */
SH_VVLOG("shadow_fault - EXIT: wr fault on RO page (%lx)", gpte);
- shadow_unlock(d);
- return 0;
+ goto fail;
}
l1pte_write_fault(d, &gpte, &spte);
/* XXX Watch out for read-only L2 entries! (not used in Linux). */
if ( unlikely(__put_user(gpte, (unsigned long *)
&linear_pg_table[va >> PAGE_SHIFT])) )
+ {
domain_crash();
+ goto fail;
+ }
/*
* Update of shadow PTE can fail because the L1 p.t. is not shadowed,
check_pagetable(d, ed->arch.guest_table, "post-sf");
return EXCRET_fault_fixed;
+
+ fail:
+ shadow_unlock(d);
+ return 0;
}
show_registers(regs);
panic("CPU%d FATAL TRAP: vector = 3 (Int3)\n", smp_processor_id());
}
-#ifdef DOMU_DEBUG
- else if ( KERNEL_MODE(ed, regs) && ed->domain->id != 0 )
- {
- if ( !test_and_set_bit(EDF_CTRLPAUSE, &ed->ed_flags) ) {
- while (ed == current)
- __enter_scheduler();
- domain_pause_by_systemcontroller(ed->domain);
- }
-
- return 0;
- }
-#endif /* DOMU_DEBUG */
+
ti = current->arch.traps + 3;
tb->flags = TBF_EXCEPTION;
tb->cs = ti->cs;
struct exec_domain *ed = current;
struct trap_bounce *tb = &ed->arch.trap_bounce;
- DEBUGGER_trap_entry(TRAP_debug, regs);
-
__asm__ __volatile__("mov %%db6,%0" : "=r" (condition));
/* Mask out spurious debug traps due to lazy DR7 setting */
goto out;
}
+ DEBUGGER_trap_entry(TRAP_debug, regs);
+
if ( !GUEST_MODE(regs) )
{
/* Clear TF just for absolute sanity. */
*/
goto out;
}
-#ifdef DOMU_DEBUG
- else if ( KERNEL_MODE(ed, regs) && ed->domain->id != 0 )
- {
- regs->eflags &= ~EF_TF;
- if ( !test_and_set_bit(EDF_CTRLPAUSE, &ed->ed_flags) ) {
- while (ed == current)
- __enter_scheduler();
- domain_pause_by_systemcontroller(ed->domain);
- }
- goto out;
- }
-#endif /* DOMU_DEBUG */
/* Save debug status register where guest OS can peek at it */
ed->arch.debugreg[6] = condition;
#include <xen/lib.h>
#include <xen/trace.h>
#include <xen/sched.h>
+#include <xen/softirq.h>
#include <asm/current.h>
#include <asm/io.h>
#include <asm/irq.h>
vio = (vcpu_iodata_t *) d->arch.arch_vmx.vmx_platform.shared_page_va;
if (vio == 0) {
VMX_DBG_LOG(DBG_LEVEL_1, "bad shared page: %lx", (unsigned long) vio);
- domain_crash();
+ domain_crash_synchronous();
}
p = &vio->vp_ioreq;
p->dir = test_bit(3, &exit_qualification);
printk("stringio crosses page boundary!\n");
if (p->u.data & (p->size - 1)) {
printk("Not aligned I/O!\n");
- domain_crash();
+ domain_crash_synchronous();
}
p->count = (PAGE_SIZE - (p->u.data & ~PAGE_MASK)) / p->size;
} else {
{
VMX_DBG_LOG(DBG_LEVEL_VMMU, "Invalid CR3 value = %lx",
d->arch.arch_vmx.cpu_cr3);
- domain_crash(); /* need to take a clean path */
+ domain_crash_synchronous(); /* need to take a clean path */
}
old_base_mfn = pagetable_val(d->arch.guest_table) >> PAGE_SHIFT;
{
VMX_DBG_LOG(DBG_LEVEL_VMMU,
"Invalid CR3 value=%lx", value);
- domain_crash(); /* need to take a clean path */
+ domain_crash_synchronous(); /* need to take a clean path */
}
mfn = phys_to_machine_mapping(value >> PAGE_SHIFT);
vmx_shadow_clear_state(d->domain);
/*
* Need to use this exit to rescheule
*/
-static inline void vmx_vmexit_do_hlt()
+static inline void vmx_vmexit_do_hlt(void)
{
#if VMX_DEBUG
unsigned long eip;
__vmread(GUEST_EIP, &eip);
#endif
VMX_DBG_LOG(DBG_LEVEL_1, "vmx_vmexit_do_hlt:eip=%p", eip);
- __enter_scheduler();
+ raise_softirq(SCHEDULE_SOFTIRQ);
}
-static inline void vmx_vmexit_do_mwait()
+static inline void vmx_vmexit_do_mwait(void)
{
#if VMX_DEBUG
unsigned long eip;
__vmread(GUEST_EIP, &eip);
#endif
VMX_DBG_LOG(DBG_LEVEL_1, "vmx_vmexit_do_mwait:eip=%p", eip);
- __enter_scheduler();
+ raise_softirq(SCHEDULE_SOFTIRQ);
}
#define BUF_SIZ 256
VMX_DBG_LOG(DBG_LEVEL_0, "exit reason = %x", exit_reason);
if (exit_reason & VMX_EXIT_REASONS_FAILED_VMENTRY) {
- domain_crash();
+ domain_crash_synchronous();
return;
}
if (num >= MAX_IO_HANDLER) {
printk("no extra space, register io interceptor failed!\n");
- domain_crash();
+ domain_crash_synchronous();
}
handler->hdl_list[num].addr = addr;
if (vio == 0) {
VMX_DBG_LOG(DBG_LEVEL_1,
"bad shared page: %lx", (unsigned long) vio);
- domain_crash();
+ domain_crash_synchronous();
}
p = &vio->vp_ioreq;
if (vio == 0) {
VMX_DBG_LOG(DBG_LEVEL_1,
"bad shared page: %lx", (unsigned long) vio);
- domain_crash();
+ domain_crash_synchronous();
}
return find_highest_irq(&vio->vp_intr[0]);
if (vio == 0) {
VMX_DBG_LOG(DBG_LEVEL_1,
"bad shared page: %lx", (unsigned long) vio);
- domain_crash();
+ domain_crash_synchronous();
}
clear_bit(vector, &vio->vp_intr[0]);
if (vio == NULL) {
printk("bad shared page\n");
- domain_crash();
+ domain_crash_synchronous();
}
p = &vio->vp_ioreq;
ret = inst_copy_from_guest(inst, eip, inst_len);
if (ret != inst_len) {
printk("handle_mmio - EXIT: get guest instruction fault\n");
- domain_crash();
+ domain_crash_synchronous();
}
init_instruction(&mmio_inst);
if (vmx_decode(check_prefix(inst, &mmio_inst), &mmio_inst) == DECODE_failure)
- domain_crash();
+ domain_crash_synchronous();
__vmwrite(GUEST_EIP, eip + inst_len);
store_xen_regs(inst_decoder_regs);
return ;
} else {
printk("handle_mmio - EXIT: movz error!\n");
- domain_crash();
+ domain_crash_synchronous();
}
}
index = operand_index(mmio_inst.operand[0]);
value = get_reg_value(size, index, 0, inst_decoder_regs);
} else {
- domain_crash();
+ domain_crash_synchronous();
}
send_mmio_req(gpa, &mmio_inst, value, 0, 0);
return;
}
- domain_crash();
}
- domain_crash();
+
+ domain_crash_synchronous();
}
#endif /* CONFIG_VMX */
movb $0,TRAPBOUNCE_flags(%edx)
ret
.section __ex_table,"a"
- .long FLT6,domain_crash , FLT7,domain_crash , FLT8,domain_crash
- .long FLT9,domain_crash , FLT10,domain_crash , FLT11,domain_crash
- .long FLT12,domain_crash , FLT13,domain_crash , FLT14,domain_crash
- .long FLT15,domain_crash , FLT16,domain_crash , FLT17,domain_crash
- .long FLT18,domain_crash , FLT19,domain_crash , FLT20,domain_crash
- .long FLT21,domain_crash , FLT22,domain_crash , FLT23,domain_crash
- .long FLT24,domain_crash , FLT25,domain_crash , FLT26,domain_crash
+ .long FLT6,domain_crash_synchronous , FLT7,domain_crash_synchronous
+ .long FLT8,domain_crash_synchronous , FLT9,domain_crash_synchronous
+ .long FLT10,domain_crash_synchronous , FLT11,domain_crash_synchronous
+ .long FLT12,domain_crash_synchronous , FLT13,domain_crash_synchronous
+ .long FLT14,domain_crash_synchronous , FLT15,domain_crash_synchronous
+ .long FLT16,domain_crash_synchronous , FLT17,domain_crash_synchronous
+ .long FLT18,domain_crash_synchronous , FLT19,domain_crash_synchronous
+ .long FLT20,domain_crash_synchronous , FLT21,domain_crash_synchronous
+ .long FLT22,domain_crash_synchronous , FLT23,domain_crash_synchronous
+ .long FLT24,domain_crash_synchronous , FLT25,domain_crash_synchronous
+ .long FLT26,domain_crash_synchronous
.previous
ALIGN
jmp test_all_events
.section __ex_table,"a"
- .long VFLT1,domain_crash
- .long VFLT2,domain_crash
- .long VFLT3,domain_crash
+ .long VFLT1,domain_crash_synchronous
+ .long VFLT2,domain_crash_synchronous
+ .long VFLT3,domain_crash_synchronous
.previous
.data
jb 1f # In +ve address space? Then okay.
movq $HYPERVISOR_VIRT_END+60,%rax
cmpq %rax,%rsi
- jb domain_crash # Above Xen private area? Then okay.
+ jb domain_crash_synchronous # Above Xen private area? Then okay.
1: subq $40,%rsi
movq XREGS_ss+8(%rsp),%rax
FLT2: movq %rax,32(%rsi) # SS
movb $0,TRAPBOUNCE_flags(%rdx)
ret
.section __ex_table,"a"
- .quad FLT2,domain_crash , FLT3,domain_crash , FLT4,domain_crash
- .quad FLT5,domain_crash , FLT6,domain_crash , FLT7,domain_crash
- .quad FLT8,domain_crash , FLT9,domain_crash , FLT10,domain_crash
- .quad FLT11,domain_crash , FLT12,domain_crash , FLT13,domain_crash
- .quad FLT14,domain_crash
+ .quad FLT2,domain_crash_synchronous , FLT3,domain_crash_synchronous
+ .quad FLT4,domain_crash_synchronous , FLT5,domain_crash_synchronous
+ .quad FLT6,domain_crash_synchronous , FLT7,domain_crash_synchronous
+ .quad FLT8,domain_crash_synchronous , FLT9,domain_crash_synchronous
+ .quad FLT10,domain_crash_synchronous , FLT11,domain_crash_synchronous
+ .quad FLT12,domain_crash_synchronous , FLT13,domain_crash_synchronous
+ .quad FLT14,domain_crash_synchronous
.previous
ALIGN
set_bit(DF_CRASHED, &d->d_flags);
send_guest_virq(dom0->exec_domain[0], VIRQ_DOM_EXC);
-
- __enter_scheduler();
- BUG();
+
+ raise_softirq(SCHEDULE_SOFTIRQ);
+}
+
+
+void domain_crash_synchronous(void)
+{
+ domain_crash();
+ for ( ; ; )
+ do_softirq();
}
-extern void trap_to_xendbg(void);
void domain_shutdown(u8 reason)
{
}
}
- if ( reason == SHUTDOWN_crash )
- {
- domain_crash();
- BUG();
- }
-
- d->shutdown_code = reason;
- set_bit(DF_SHUTDOWN, &d->d_flags);
+ if ( (d->shutdown_code = reason) == SHUTDOWN_crash )
+ set_bit(DF_CRASHED, &d->d_flags);
+ else
+ set_bit(DF_SHUTDOWN, &d->d_flags);
send_guest_virq(dom0->exec_domain[0], VIRQ_DOM_EXC);
- __enter_scheduler();
+ raise_softirq(SCHEDULE_SOFTIRQ);
}
unsigned int alloc_new_dom_mem(struct domain *d, unsigned int kbytes)
struct schedule_data schedule_data[NR_CPUS];
extern struct scheduler sched_bvt_def;
-// extern struct scheduler sched_rrobin_def;
-// extern struct scheduler sched_atropos_def;
static struct scheduler *schedulers[] = {
&sched_bvt_def,
-// &sched_rrobin_def,
-// &sched_atropos_def,
NULL
};
-/* Operations for the current scheduler. */
+static void __enter_scheduler(void);
+
static struct scheduler ops;
#define SCHED_OP(fn, ...) \
* - deschedule the current domain (scheduler independent).
* - pick a new domain (scheduler dependent).
*/
-void __enter_scheduler(void)
+static void __enter_scheduler(void)
{
struct exec_domain *prev = current, *next = NULL;
int cpu = prev->processor;
* **************************************************************
*/
-extern void trap_to_xendbg(void);
-
void panic(const char *fmt, ...)
{
va_list args;
#ifndef __X86_DEBUGGER_H__
#define __X86_DEBUGGER_H__
+#include <xen/softirq.h>
#include <asm/processor.h>
/* The main trap handlers use these helper macros which include early bail. */
int call_with_registers(int (*f)(struct xen_regs *r));
-#ifdef XEN_DEBUGGER
+#if defined(CRASH_DEBUG)
-#include <asm/pdb.h>
+extern int __trap_to_cdb(struct xen_regs *r);
+#define debugger_trap_entry(_v, _r) (0)
+#define debugger_trap_fatal(_v, _r) __trap_to_cdb(_r)
+#define debugger_trap_immediate() call_with_registers(__trap_to_cdb)
+
+#elif defined(DOMU_DEBUG)
static inline int debugger_trap_entry(
unsigned int vector, struct xen_regs *regs)
{
- int ret = 0;
+ struct exec_domain *ed = current;
+ if ( !KERNEL_MODE(ed, regs) || (ed->domain->id == 0) )
+ return 0;
+
switch ( vector )
{
- case TRAP_debug:
- if ( pdb_initialized )
- {
- pdb_handle_debug_trap(regs, regs->error_code);
- ret = 1; /* early exit */
- }
- break;
-
case TRAP_int3:
- if ( pdb_initialized && (pdb_handle_exception(vector, regs) == 0) )
- ret = 1; /* early exit */
- break;
-
- case TRAP_gp_fault:
- if ( (VM86_MODE(regs) || !RING_0(regs)) &&
- ((regs->error_code & 3) == 2) &&
- pdb_initialized && (pdb_ctx.system_call != 0) )
- {
- unsigned long cr3 = read_cr3();
- if ( cr3 == pdb_ctx.ptbr )
- pdb_linux_syscall_enter_bkpt(
- regs, regs->error_code,
- current->thread.traps + (regs->error_code>>3));
- }
- break;
- }
-
- return ret;
-}
-
-static inline int debugger_trap_fatal(
- unsigned int vector, struct xen_regs *regs)
-{
- int ret = 0;
-
- switch ( vector )
- {
- case TRAP_page_fault:
- if ( pdb_page_fault_possible )
- {
- pdb_page_fault = 1;
- /* make eax & edx valid to complete the instruction */
- regs->eax = (long)&pdb_page_fault_scratch;
- regs->edx = (long)&pdb_page_fault_scratch;
- ret = 1; /* exit - do not crash! */
- }
- break;
+ case TRAP_debug:
+ set_bit(EDF_CTRLPAUSE, &ed->ed_flags);
+ raise_softirq(SCHEDULE_SOFTIRQ);
+ return 1;
}
- return ret;
+ return 0;
}
-#define debugger_trap_immediate() ()
-
-#elif defined(CRASH_DEBUG)
+#define debugger_trap_fatal(_v, _r) (0)
+#define debugger_trap_immediate()
-extern int __trap_to_cdb(struct xen_regs *r);
-#define debugger_trap_entry(_v, _r) (0)
-#define debugger_trap_fatal(_v, _r) __trap_to_cdb(_r)
-#define debugger_trap_immediate() call_with_registers(__trap_to_cdb)
#elif 0
do { \
printk("__vmx_bug at %s:%d\n", __FILE__, __LINE__); \
show_registers(regs); \
- domain_crash(); \
+ domain_crash_synchronous(); \
} while (0)
#endif /* ASM_X86_VMX_VMCS_H__ */
struct domain *find_last_domain(void);
extern void domain_destruct(struct domain *d);
extern void domain_kill(struct domain *d);
-extern void domain_crash(void);
extern void domain_shutdown(u8 reason);
+/*
+ * Mark current domain as crashed. This function returns: the domain is not
+ * synchronously descheduled from any processor.
+ */
+extern void domain_crash(void);
+
+/*
+ * Mark current domain as crashed and synchronously deschedule from the local
+ * processor. This function never returns.
+ */
+extern void domain_crash_synchronous(void) __attribute__((noreturn));
+
void new_thread(struct exec_domain *d,
unsigned long start_pc,
unsigned long start_stack,
void domain_wake(struct exec_domain *d);
void domain_sleep(struct exec_domain *d);
-void __enter_scheduler(void);
-
extern void context_switch(
struct exec_domain *prev,
struct exec_domain *next);
projects / xen.git / commitdiff